﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Tools.TraceVisualiser.Support
{
//    internal class Rtf
//    {
//        public static string Header
//        {
//            get
//            {
//                return @"{\rtf1\ansi\deff0{\fonttbl{\f0\fnil\fcharset238{\*\fname Courier New;}Courier New CE;}}
//{\*\generator Msftedit 5.41.15.1515;}\viewkind4\uc1\pard\lang1029\f0\fs20 ";
//            }
//        }
//        public Rtf()
//        {
//            this.RtfItems = new List<RtfItem>();
//            this.ReadOnly = true;
//        }
//        public Rtf(bool readOnly)
//        {
//            this.RtfItems = new List<RtfItem>();
//            this.ReadOnly = readOnly;
//        }
//        /// <summary>
//        /// Do RTF dokumentu přidá další segmenty.
//        /// Segmenty se vytvářejí pomocí statických konstruktorů třídy RtfItem, typicky: .Add(RtfItem.NewText("text do RTF dokumentu."))
//        /// </summary>
//        /// <param name="item"></param>
//        public void Add(params RtfItem[] items)
//        {
//            if (items != null)
//            {
//                foreach (RtfItem item in items)
//                {
//                    if (!item.IsEmpty)
//                        this.RtfItems.Add(item);
//                }
//            }
//        }
//        /// <summary>
//        /// Obsahuje vždy platný aktuální RTF text
//        /// </summary>
//        public string RtfText
//        {
//            get { return this._CreateRtfText(); }
//        }
//        public List<RtfItem> RtfItems { get; private set; }
//        public bool ReadOnly { get; set; }
//        #region Kompletace RTF textu
//        /// <summary>
//        /// Zkompletuje RTF text
//        /// </summary>
//        /// <returns></returns>
//        private string _CreateRtfText()
//        {
//            // Nejdřív musím projít položky RtfItems, protože tím se mi vytvoří tabulka fontů a tabulka barev, kteréžto patří do záhlaví před vlastní text:
//            StringBuilder txt = new StringBuilder();
//            List<RtfFont> fontTable = new List<RtfFont>();
//            fontTable.Add(new RtfFont(0, 238, "nil", "Courier New", "Courier New CE"));

//            List<RtfColor> colorTable = new List<RtfColor>();
//            colorTable.Add(new RtfColor(0, Color.Empty));

//            Dictionary<int, string> codeTable = _CreateRtfCodeTable();
//            bool inCode = true;
//            foreach (RtfItem item in this.RtfItems)
//            {
//                string fragment = null;
//                switch (item.ItemType)
//                {
//                    case RtfItemType.None:
//                        break;
//                    case RtfItemType.Text:
//                        fragment = _ItemCreateRtfText(item, ref inCode, codeTable);
//                        break;
//                    case RtfItemType.Code:
//                        fragment = _ItemCreateRtfCode(item, ref inCode);
//                        break;
//                    case RtfItemType.FontName:
//                        fragment = _ItemCreateRtfFont(item, ref inCode, fontTable);
//                        break;
//                    case RtfItemType.FontSize:
//                        fragment = _ItemCreateRtfSize(item, ref inCode);
//                        break;
//                    case RtfItemType.FontStyle:
//                        fragment = _ItemCreateRtfStyle(item, ref inCode);
//                        break;
//                    case RtfItemType.ForeColor:
//                        fragment = _ItemCreateRtfColor(item, ref inCode, colorTable);
//                        break;
//                    case RtfItemType.BackColor:
//                        fragment = _ItemCreateRtfColor(item, ref inCode, colorTable);
//                        break;
//                    case RtfItemType.Highlight:
//                        fragment = _ItemCreateRtfHighlightColor(item, ref inCode);
//                        break;
//                    case RtfItemType.ProtectState:
//                        break;
//                    case RtfItemType.ParagraphAlignment:
//                        fragment = _ItemCreateRtfAlign(item, ref inCode);
//                        break;
//                }
//                if (fragment != null)
//                    txt.Append(fragment);
//            }

//            // Kompletace RTF: hlavička
//            StringBuilder rtf = new StringBuilder();
//            rtf.Append(@"{\rtf1\ansi\ansicpg1250\deff0");

//            // fonty
//            if (fontTable.Count > 0)
//            {
//                rtf.Append(@"{\fonttbl");
//                foreach (RtfFont font in fontTable)
//                    rtf.Append(font.RtfTable);
//                rtf.Append(@"}");
//            }
//            // barvy
//            if (colorTable.Count > 1)
//            {
//                rtf.AppendLine();
//                rtf.Append(@"{\colortbl ");
//                foreach (RtfColor color in colorTable)
//                    rtf.Append(color.RtfTable);
//                rtf.Append(@"}");
//            }
//            // záhlaví před prvním textem:
//            rtf.AppendLine();
//            rtf.Append(@"{\*\generator Msftedit 5.41.21.2510;}\viewkind4" + (this.ReadOnly ? @"\allprot" : "") + @"\uc1\pard\lang1029\f0\fs20");

//            // text:
//            rtf.Append(txt.ToString());

//            // zápatí:
//            rtf.AppendLine();
//            rtf.AppendLine("}");
//            rtf.Append(" ");

//            return rtf.ToString();
//        }
//        private Dictionary<int, string> _CreateRtfCodeTable()
//        {
//            Dictionary<int, string> codeTable = new Dictionary<int, string>();

//            codeTable.Add(09, @"\tab");        // TAB
//            codeTable.Add(10, "");             // LF = nic
//            codeTable.Add(13, @"\par\r\n");    // CR = text "\par" + CrLf (vizuální oddělení textu)
//            codeTable.Add(92, @"\\");          // Jedno zpětné lomítko => nahradit dvěma

//            return codeTable;
//        }
//        private string _ItemCreateRtfText(RtfItem item, ref bool inCode, Dictionary<int, string> codeTable)
//        {
//            StringBuilder sb = new StringBuilder();
//            if (item.Text != null)
//            {
//                foreach (char c in item.Text)
//                {
//                    int i = (int)c;
//                    string code;
//                    // Znaky 128 a vyšší:
//                    if (i >= 128 && !codeTable.ContainsKey(i))
//                    {
//                        if (i <= 255)
//                        {   // Unicode znaku se vejde do jednoho byte:
//                            code = @"\'" + i.ToString("X2").ToLower();
//                        }
//                        else
//                        {   // Unicode je větší než 1 byte, vypíšu jej jinak:
//                            code = @"\u" + i.ToString() + "?";
//                        }

//                        //Encoding ec = Encoding.GetEncoding(852);
//                        //byte[] dc = ec.GetBytes(new char[] { c });

//                        //Encoding ec2 = Encoding.GetEncoding(1250);
//                        //byte[] dc2 = ec2.GetBytes(new char[] { c });


//                        //code = @"\'";
//                        //int h = dc[0];
//                        //if (dc.Length == 1)
//                        //    code += (dc[0]).ToString("X2");
//                        //else if (dc.Length == 2)
//                        //    code += (dc[0] + dc[1] * 0x100).ToString("X4");

//                        codeTable.Add(i, code);
//                    }

//                    // Pokud znak je obsažen v codeTable, vypíšu jej jako kód:
//                    if (codeTable.TryGetValue(i, out code))
//                    {
//                        sb.Append(code);
//                        inCode = (i < 32);              // Řídící kód je to jen pro znaky menší než 128. Znaky s vyšším ASCII kódem jsou písmena a za nimi se mezera nepřidává...
//                    }
//                    else
//                    {
//                        if (inCode)
//                        {	// Po kódu, před textem se vkládá mezera:
//                            sb.Append(" ");
//                            inCode = false;
//                        }
//                        sb.Append(c);
//                    }
//                }
//            }
//            return sb.ToString();
//        }
//        private string _ItemCreateRtfCode(RtfItem item, ref bool inCode)
//        {
//            inCode = true;
//            return item.Code;
//        }
//        private string _ItemCreateRtfFont(RtfItem item, ref bool inCode, List<RtfFont> fontTable)
//        {
//            RtfFont font = fontTable.FirstOrDefault(ft => ft.FontName == item.FontName);
//            if (font == null)
//            {
//                font = new RtfFont(fontTable.Count, 238, "swiss", item.FontName, item.FontName);
//                fontTable.Add(font);
//            }
//            inCode = true;
//            return font.RtfMark;
//        }
//        private string _ItemCreateRtfSize(RtfItem item, ref bool inCode)
//        {
//            inCode = true;
//            return @"\fs" + (2 * item.FontSize).ToString();
//        }
//        private string _ItemCreateRtfStyle(RtfItem item, ref bool inCode)
//        {
//            switch (item.FontStyle)
//            {
//                case RtfFontStyle.Bold:
//                    inCode = true;
//                    return @"\b";
//                case RtfFontStyle.BoldEnd:
//                    inCode = true;
//                    return @"\b0";
//                case RtfFontStyle.Italic:
//                    inCode = true;
//                    return @"\i";
//                case RtfFontStyle.ItalicEnd:
//                    inCode = true;
//                    return @"\i0";
//                case RtfFontStyle.Underline:
//                    inCode = true;
//                    return @"\ul";
//                case RtfFontStyle.UnderlineEnd:
//                    inCode = true;
//                    return @"\ulnone";
//                case RtfFontStyle.StrikeOut:
//                    inCode = true;
//                    return @"\strike";
//                case RtfFontStyle.StrikeOutEnd:
//                    inCode = true;
//                    return @"\strike0";
//            }
//            return @"";
//        }
//        private string _ItemCreateRtfColor(RtfItem item, ref bool inCode, List<RtfColor> colorTable)
//        {
//            RtfColor rtfColor = colorTable.FirstOrDefault(rc => rc.ColorValue.Equals(item.Color));   // Najdu položku RtfColor odpovídající zadané barvě
//            if (rtfColor == null)
//            {
//                rtfColor = new RtfColor(colorTable.Count, item.Color);
//                colorTable.Add(rtfColor);
//            }
//            switch (item.ItemType)
//            {
//                case RtfItemType.ForeColor:
//                    inCode = true;
//                    return rtfColor.RtfMarkF;
//                case RtfItemType.BackColor:
//                    inCode = true;
//                    return rtfColor.RtfMarkB;
//            }
//            return "";
//        }
//        private string _ItemCreateRtfHighlightColor(RtfItem item, ref bool inCode)
//        {
//            inCode = true;
//            return @"\highlight" + ((int)item.HighlightColor).ToString();
//        }
//        private string _ItemCreateRtfAlign(RtfItem item, ref bool inCode)
//        {
//            switch (item.Alignment)
//            {
//                case RtfAlignment.Left:
//                    inCode = true;
//                    return @"";
//                case RtfAlignment.Center:
//                    inCode = true;
//                    return @"\qc";
//                case RtfAlignment.Right:
//                    inCode = true;
//                    return @"\qr";
//                case RtfAlignment.Justify:
//                    inCode = true;
//                    return @"\qj";
//            }
//            return @"";
//        }
//        #endregion
//    }
//    #region CLASS RtfFont, RtfColor
//    /// <summary>
//    /// Úložiště jednoho fontu v tabulce fontů RTF
//    /// </summary>
//    internal class RtfFont
//    {
//        public RtfFont(int index, string name)
//        {
//            this.FontCode = index.ToString();
//            this.FontCharset = "238";
//            this.FontType = "nil";
//            this.FontFamily = name;
//            this.FontName = name;
//        }
//        public RtfFont(int index, string family, string name)
//        {
//            this.FontCode = index.ToString();
//            this.FontCharset = "238";
//            this.FontType = "nil";
//            this.FontFamily = family;
//            this.FontName = name;
//        }
//        public RtfFont(int index, int charSet, string family, string name)
//        {
//            this.FontCode = index.ToString();
//            this.FontCharset = charSet.ToString();
//            this.FontType = "nil";
//            this.FontFamily = family;
//            this.FontName = name;
//        }
//        public RtfFont(int index, int charSet, string type, string family, string name)
//        {
//            this.FontCode = index.ToString();
//            this.FontCharset = charSet.ToString();
//            this.FontType = type;
//            this.FontFamily = family;
//            this.FontName = name;
//        }
//        public string FontCode { get; private set; }
//        public string FontCharset { get; private set; }
//        public string FontType { get; private set; }
//        public string FontFamily { get; private set; }
//        public string FontName { get; private set; }
//        /// <summary>
//        /// Značka fontu do flow textu: \f3   
//        /// </summary>
//        public string RtfMark { get { return @"\f" + this.FontCode; } }
//        /// <summary>
//        /// Plný text fontu do tabulky fontů: {\f3\fnil\fcharset238{\*\fname Arial;}Arial CE;}
//        /// </summary>
//        public string RtfTable
//        {
//            get
//            {
//                return @"{\f" + this.FontCode + @"\f" + this.FontType + @"\fcharset" + this.FontCharset + @"{\*\fname " + this.FontFamily + @";}" + this.FontName + ";}";
//            }
//        }
//    }
//    /// <summary>
//    /// Úložiště jedné barvy v paletě barev
//    /// </summary>
//    internal class RtfColor
//    {
//        public RtfColor(int index, Color color)
//        {
//            this.ColorCode = index.ToString();
//            this.ColorValue = color;
//        }
//        /// <summary>
//        /// Obsahuje kód barvy = text "cf0" až "cf199"
//        /// </summary>
//        public string ColorCode { get; private set; }
//        /// <summary>
//        /// Obsahuje barvu. Pokud je IsEmpty, jde o default barvu která se do tabulky nevypisuje (její hodnoty), ale jen se z aní vkládá středník.
//        /// </summary>
//        public Color ColorValue { get; private set; }
//        /// <summary>
//        /// Značka fontu do flow textu: \cf1   (pro barvu ForeColor)
//        /// </summary>
//        public string RtfMarkF { get { return @"\cf" + this.ColorCode; } }
//        /// <summary>
//        /// Značka fontu do flow textu: \cb1   (pro barvu BackColor)
//        /// </summary>
//        public string RtfMarkB { get { return @"\cb" + this.ColorCode; } }
//        /// <summary>
//        /// Značka fontu do flow textu: \cb1   (pro barvu BackColor)
//        /// </summary>
//        public string RtfMarkH { get { return @"\cb" + this.ColorCode; } }
        
//        /// <summary>
//        /// Text barvy v RTF kódu: "red0\green128\blue64;"
//        /// </summary>
//        public string RtfTable
//        {
//            get
//            {
//                if (this.ColorValue.IsEmpty)
//                    return ";";
//                return "red" + this.ColorValue.R.ToString() + "\\green" + this.ColorValue.G.ToString() + "\\blue" + this.ColorValue.B.ToString() + ";";
//            }
//        }
//    }
//    #endregion
//    #region CLASS RtfItem, enum RtfItemType
//    internal class RtfItem
//    {
//        #region Private konstruktory (ItemType, Value)
//        private RtfItem(RtfItemType itemType, string value)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.Text:
//                    this.Text = value;
//                    break;
//                case RtfItemType.Code:
//                    this.Code = value;
//                    break;
//                case RtfItemType.FontName:
//                    this.FontName = value;
//                    break;

//            }
//        }
//        private RtfItem(RtfItemType itemType, int value)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.FontSize:
//                    this.FontSize = value;
//                    break;
//            }
//        }
//        private RtfItem(RtfItemType itemType, Color value)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.BackColor:
//                case RtfItemType.ForeColor:
//                    this.Color = value;
//                    break;
//            }
//        }
//        private RtfItem(RtfItemType itemType, RtfHighlightColor highlightColor)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.Highlight:
//                    this.HighlightColor = highlightColor;
//                    break;
//            }
//        }
//        private RtfItem(RtfItemType itemType, RtfFontStyle fontStyle)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.FontStyle:
//                    this.FontStyle = fontStyle;
//                    break;
//            }
//        }
//        private RtfItem(RtfItemType itemType, RtfAlignment alignment)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.ParagraphAlignment:
//                    this.Alignment = alignment;
//                    break;
//            }
//        }
//        private RtfItem(RtfItemType itemType, bool value)
//        {
//            this._Reset(itemType);
//            switch (itemType)
//            {
//                case RtfItemType.ProtectState:
//                    this.IsProtected = value;
//                    break;
//            }
//        }
//        private void _Reset(RtfItemType itemType)
//        {
//            this.ItemType = itemType;
//            this.Text = null;
//            this.FontName = null;
//            this.FontSize = 0;
//            this.Color = Color.Empty;
//            this.IsProtected = false;
//        }
//        #endregion
//        #region Property
//        public bool IsEmpty { get { return this.ItemType == RtfItemType.None; } }
//        public RtfItemType ItemType { get; private set; }
//        /// <summary>
//        /// Čitelný text, pokud v tomto prvku má co pohledávat
//        /// </summary>
//        public string Text { get; private set; }
//        /// <summary>
//        /// Explicitně zadaný vnitřní kód
//        /// </summary>
//        public string Code { get; private set; }
//        public string FontName { get; private set; }
//        public int FontSize { get; private set; }
//        public RtfFontStyle FontStyle { get; private set; }
//        public Color Color { get; private set; }
//        public RtfHighlightColor HighlightColor { get; private set; }
//        public bool IsProtected { get; private set; }
//        public RtfAlignment Alignment { get; private set; }
//        #endregion
//        #region Static konstruktory
//        public static RtfItem NewText(string text)
//        {
//            return new RtfItem(RtfItemType.Text, text);
//        }
//        public static RtfItem NewText(string text, bool addNewLine)
//        {
//            return new RtfItem(RtfItemType.Text, text + (addNewLine ? "\r" : ""));
//        }
//        /// <summary>
//        /// Obsahuje znak pro nový řádek
//        /// </summary>
//        public static RtfItem NewLine { get { return new RtfItem(RtfItemType.Text, "\r"); } }
//        /// <summary>
//        /// Obsahuje znak pro defaultní odstavec
//        /// </summary>
//        public static RtfItem DefaultParagraph { get { return new RtfItem(RtfItemType.Code, @"\pard"); } }
//        public static RtfItem NewFont(string fontName)
//        {
//            return new RtfItem(RtfItemType.FontName, fontName);
//        }
//        public static RtfItem NewSize(int fontSize)
//        {
//            return new RtfItem(RtfItemType.FontName, fontSize);
//        }
//        public static RtfItem NewFontStyle(RtfFontStyle fontStyle)
//        {
//            return new RtfItem(RtfItemType.FontStyle, fontStyle);
//        }
//        public static RtfItem NewParAlignment(RtfAlignment alignment)
//        {
//            return new RtfItem(RtfItemType.ParagraphAlignment, alignment);
//        }
//        public static RtfItem NewBackColor(Color color)
//        {
//            return new RtfItem(RtfItemType.BackColor, color);
//        }
//        public static RtfItem NewForeColor(Color color)
//        {
//            return new RtfItem(RtfItemType.ForeColor, color);
//        }
//        public static RtfItem NewHighlight(RtfHighlightColor color)
//        {
//            return new RtfItem(RtfItemType.Highlight, color);
//        }
//        public static RtfItem NewProtect(bool isProtected)
//        {
//            return new RtfItem(RtfItemType.ProtectState, isProtected);
//        }
//        #endregion
//    }
//    public enum RtfItemType
//    {
//        None,
//        Text,
//        Code,
//        FontName,
//        FontSize,
//        FontStyle,
//        ForeColor,
//        BackColor,
//        Highlight,
//        ProtectState,
//        ParagraphAlignment
//    }
//    public enum RtfAlignment
//    {
//        None,
//        Left,
//        Center,
//        Right,
//        Justify
//    }
//    [Flags]
//    public enum RtfFontStyle
//    {
//        None = 0,
//        Bold = 0x01,
//        BoldEnd = 0x02,
//        Italic = 0x04,
//        ItalicEnd = 0x08,
//        Underline = 0x10,
//        UnderlineEnd = 0x20,
//        StrikeOut = 0x40,
//        StrikeOutEnd = 0x80
//    }
//    public enum RtfHighlightColor
//    {
//        None = 0,
//        Black = 1,
//        Blue = 2,
//        Cyan = 3,
//        Green = 4,
//        Magenta = 5,
//        Red = 6,
//        Yellow = 7,
//        DarkBlue = 9,
//        DarkCyan = 10,
//        DarkGreen = 11,
//        DarkMagenta = 12,
//        DarkRed = 13,
//        DarkYellow = 14,
//        DarkGray = 15,
//        LightGray = 16
//    }
//    #endregion
}
